home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / site-packages / gtk-2.0 / dsextras.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2006-01-20  |  12KB  |  357 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. from distutils.command.build_ext import build_ext
  5. from distutils.command.install_lib import install_lib
  6. from distutils.command.install_data import install_data
  7. from distutils.extension import Extension
  8. import fnmatch
  9. import os
  10. import re
  11. import string
  12. import sys
  13. GLOBAL_INC = []
  14. GLOBAL_MACROS = []
  15.  
  16. def get_m4_define(varname):
  17.     '''Return the value of a m4_define variable as set in configure.in.'''
  18.     pattern = re.compile('m4_define\\(' + varname + '\\,\\s*(.+)\\)')
  19.     for line in open('configure.in').readlines():
  20.         match_obj = pattern.match(line)
  21.         if match_obj:
  22.             return match_obj.group(1)
  23.             continue
  24.     
  25.  
  26.  
  27. def getoutput(cmd):
  28.     '''Return output (stdout or stderr) of executing cmd in a shell.'''
  29.     return getstatusoutput(cmd)[1]
  30.  
  31.  
  32. def getstatusoutput(cmd):
  33.     '''Return (status, output) of executing cmd in a shell.'''
  34.     if sys.platform == 'win32':
  35.         pipe = os.popen(cmd, 'r')
  36.         text = pipe.read()
  37.         if not pipe.close():
  38.             pass
  39.         sts = 0
  40.         if text[-1:] == '\n':
  41.             text = text[:-1]
  42.         
  43.         return (sts, text)
  44.     else:
  45.         getstatusoutput = getstatusoutput
  46.         import commands
  47.         return getstatusoutput(cmd)
  48.  
  49.  
  50. def have_pkgconfig():
  51.     '''Checks for the existence of pkg-config'''
  52.     if sys.platform == 'win32' and os.system('pkg-config --version > NUL') == 0:
  53.         return 1
  54.     elif getstatusoutput('pkg-config')[0] == 256:
  55.         return 1
  56.     
  57.  
  58.  
  59. def list_files(dir):
  60.     '''List all files in a dir, with filename match support:
  61.     for example: glade/*.glade will return all files in the glade directory
  62.     that matches *.glade. It also looks up the full path'''
  63.     if dir.find(os.sep) != -1:
  64.         parts = dir.split(os.sep)
  65.         dir = string.join(parts[:-1], os.sep)
  66.         pattern = parts[-1]
  67.     else:
  68.         pattern = dir
  69.         dir = '.'
  70.     dir = os.path.abspath(dir)
  71.     retval = []
  72.     for file in os.listdir(dir):
  73.         if fnmatch.fnmatch(file, pattern):
  74.             retval.append(os.path.join(dir, file))
  75.             continue
  76.     
  77.     return retval
  78.  
  79.  
  80. def pkgc_version_check(name, longname, req_version):
  81.     is_installed = not os.system('pkg-config --exists %s' % name)
  82.     if not is_installed:
  83.         print 'Could not find %s' % longname
  84.         return 0
  85.     
  86.     orig_version = getoutput('pkg-config --modversion %s' % name)
  87.     version = map(int, orig_version.split('.'))
  88.     pkc_version = map(int, req_version.split('.'))
  89.     if version >= pkc_version:
  90.         return 1
  91.     else:
  92.         print 'Warning: Too old version of %s' % longname
  93.         print '         Need %s, but %s is installed' % (pkc_version, orig_version)
  94.         self.can_build_ok = 0
  95.         return 0
  96.  
  97.  
  98. class BuildExt(build_ext):
  99.     
  100.     def init_extra_compile_args(self):
  101.         self.extra_compile_args = []
  102.         if sys.platform == 'win32' and self.compiler.compiler_type == 'mingw32':
  103.             msnative_struct = {
  104.                 '2': '-fnative-struct',
  105.                 '3': '-mms-bitfields' }
  106.             gcc_version = getoutput('gcc -dumpversion')
  107.             print 'using MinGW GCC version %s with %s option' % (gcc_version, msnative_struct[gcc_version[0]])
  108.             self.extra_compile_args.append(msnative_struct[gcc_version[0]])
  109.         
  110.  
  111.     
  112.     def modify_compiler(self):
  113.         if sys.platform == 'win32' and self.compiler.compiler_type == 'mingw32':
  114.             if self.compiler.linker_so.count('-static'):
  115.                 self.compiler.linker_so.remove('-static')
  116.             
  117.         
  118.  
  119.     
  120.     def build_extensions(self):
  121.         self.init_extra_compile_args()
  122.         self.modify_compiler()
  123.         build_ext.build_extensions(self)
  124.  
  125.     
  126.     def build_extension(self, ext):
  127.         ext.extra_compile_args += self.extra_compile_args
  128.         if hasattr(ext, 'generate'):
  129.             ext.generate()
  130.         
  131.         build_ext.build_extension(self, ext)
  132.  
  133.  
  134.  
  135. class InstallLib(install_lib):
  136.     local_outputs = []
  137.     local_inputs = []
  138.     
  139.     def set_install_dir(self, install_dir):
  140.         self.install_dir = install_dir
  141.  
  142.     
  143.     def get_outputs(self):
  144.         return install_lib.get_outputs(self) + self.local_outputs
  145.  
  146.     
  147.     def get_inputs(self):
  148.         return install_lib.get_inputs(self) + self.local_inputs
  149.  
  150.  
  151.  
  152. class InstallData(install_data):
  153.     local_outputs = []
  154.     local_inputs = []
  155.     template_options = { }
  156.     
  157.     def prepare(self):
  158.         if os.name == 'nt':
  159.             self.prefix = os.sep.join(self.install_dir.split(os.sep)[:-3])
  160.         else:
  161.             self.prefix = os.sep.join(self.install_dir.split(os.sep)[:-4])
  162.         self.exec_prefix = '${prefix}/bin'
  163.         self.includedir = '${prefix}/include'
  164.         self.libdir = '${prefix}/lib'
  165.         self.datadir = '${prefix}/share'
  166.         self.add_template_option('prefix', self.prefix)
  167.         self.add_template_option('exec_prefix', self.exec_prefix)
  168.         self.add_template_option('includedir', self.includedir)
  169.         self.add_template_option('libdir', self.libdir)
  170.         self.add_template_option('datadir', self.datadir)
  171.         self.add_template_option('PYTHON', sys.executable)
  172.         self.add_template_option('THREADING_CFLAGS', '')
  173.  
  174.     
  175.     def set_install_dir(self, install_dir):
  176.         self.install_dir = install_dir
  177.  
  178.     
  179.     def add_template_option(self, name, value):
  180.         self.template_options['@%s@' % name] = value
  181.  
  182.     
  183.     def install_template(self, filename, install_dir):
  184.         '''Install template filename into target directory install_dir.'''
  185.         output_file = os.path.split(filename)[-1][:-3]
  186.         template = open(filename).read()
  187.         for key, value in self.template_options.items():
  188.             template = template.replace(key, value)
  189.         
  190.         output = os.path.join(install_dir, output_file)
  191.         self.mkpath(install_dir)
  192.         open(output, 'w').write(template)
  193.         self.local_inputs.append(filename)
  194.         self.local_outputs.append(output)
  195.         return output
  196.  
  197.     
  198.     def get_outputs(self):
  199.         return install_lib.get_outputs(self) + self.local_outputs
  200.  
  201.     
  202.     def get_inputs(self):
  203.         return install_lib.get_inputs(self) + self.local_inputs
  204.  
  205.  
  206.  
  207. class PkgConfigExtension(Extension):
  208.     can_build_ok = None
  209.     
  210.     def __init__(self, **kwargs):
  211.         name = kwargs['pkc_name']
  212.         kwargs['include_dirs'] = self.get_include_dirs(name) + GLOBAL_INC
  213.         kwargs['define_macros'] = GLOBAL_MACROS
  214.         kwargs['libraries'] = self.get_libraries(name)
  215.         kwargs['library_dirs'] = self.get_library_dirs(name)
  216.         self.name = kwargs['name']
  217.         self.pkc_name = kwargs['pkc_name']
  218.         self.pkc_version = kwargs['pkc_version']
  219.         del kwargs['pkc_name']
  220.         del kwargs['pkc_version']
  221.         Extension.__init__(self, **kwargs)
  222.  
  223.     
  224.     def get_include_dirs(self, name):
  225.         output = getoutput('pkg-config --cflags-only-I %s' % name)
  226.         return output.replace('-I', '').split()
  227.  
  228.     
  229.     def get_libraries(self, name):
  230.         output = getoutput('pkg-config --libs-only-l %s' % name)
  231.         return output.replace('-l', '').split()
  232.  
  233.     
  234.     def get_library_dirs(self, name):
  235.         output = getoutput('pkg-config --libs-only-L %s' % name)
  236.         return output.replace('-L', '').split()
  237.  
  238.     
  239.     def can_build(self):
  240.         '''If the pkg-config version found is good enough'''
  241.         if self.can_build_ok != None:
  242.             return self.can_build_ok
  243.         
  244.         retval = os.system('pkg-config --exists %s' % self.pkc_name)
  245.         if retval:
  246.             print '* %s.pc could not be found, bindings for %s will not be built.' % (self.pkc_name, self.name)
  247.             self.can_build_ok = 0
  248.             return 0
  249.         
  250.         orig_version = getoutput('pkg-config --modversion %s' % self.pkc_name)
  251.         version = map(int, orig_version.split('.'))
  252.         pkc_version = map(int, self.pkc_version.split('.'))
  253.         if version >= pkc_version:
  254.             self.can_build_ok = 1
  255.             return 1
  256.         else:
  257.             print 'Warning: Too old version of %s' % self.pkc_name
  258.             print '         Need %s, but %s is installed' % (self.pkc_version, orig_version)
  259.             self.can_build_ok = 0
  260.             return 0
  261.  
  262.     
  263.     def generate(self):
  264.         pass
  265.  
  266.  
  267.  
  268. class Template:
  269.     
  270.     def __init__(self, override, output, defs, prefix, register = [], load_types = None):
  271.         self.override = override
  272.         self.defs = defs
  273.         self.register = register
  274.         self.output = output
  275.         self.prefix = prefix
  276.         self.load_types = load_types
  277.  
  278.     
  279.     def check_dates(self):
  280.         if not os.path.exists(self.output):
  281.             return 0
  282.         
  283.         files = self.register[:]
  284.         files.append(self.override)
  285.         files.append(self.defs)
  286.         newest = 0
  287.         for file in files:
  288.             test = os.stat(file)[8]
  289.             if test > newest:
  290.                 newest = test
  291.                 continue
  292.         
  293.         if newest < os.stat(self.output)[8]:
  294.             return 1
  295.         
  296.         return 0
  297.  
  298.     
  299.     def generate(self):
  300.         sys.path.insert(0, 'codegen')
  301.         Overrides = Overrides
  302.         import override
  303.         DefsParser = DefsParser
  304.         import defsparser
  305.         register_types = register_types
  306.         write_source = write_source
  307.         FileOutput = FileOutput
  308.         import codegen
  309.         if self.check_dates():
  310.             return None
  311.         
  312.         for item in self.register:
  313.             dp = DefsParser(item)
  314.             dp.startParsing()
  315.             register_types(dp)
  316.         
  317.         if self.load_types:
  318.             globals = { }
  319.             execfile(self.load_types, globals)
  320.         
  321.         dp = DefsParser(self.defs)
  322.         dp.startParsing()
  323.         register_types(dp)
  324.         fd = open(self.output, 'w')
  325.         write_source(dp, Overrides(self.override), self.prefix, FileOutput(fd, self.output))
  326.         fd.close()
  327.  
  328.  
  329.  
  330. class TemplateExtension(PkgConfigExtension):
  331.     
  332.     def __init__(self, **kwargs):
  333.         name = kwargs['name']
  334.         defs = kwargs['defs']
  335.         output = defs[:-5] + '.c'
  336.         override = kwargs['override']
  337.         load_types = kwargs.get('load_types')
  338.         self.templates = []
  339.         self.templates.append(Template(override, output, defs, 'py' + name, kwargs['register'], load_types))
  340.         del kwargs['register']
  341.         del kwargs['override']
  342.         del kwargs['defs']
  343.         if load_types:
  344.             del kwargs['load_types']
  345.         
  346.         if kwargs.has_key('output'):
  347.             kwargs['name'] = kwargs['output']
  348.             del kwargs['output']
  349.         
  350.         PkgConfigExtension.__init__(self, **kwargs)
  351.  
  352.     
  353.     def generate(self):
  354.         map((lambda x: x.generate()), self.templates)
  355.  
  356.  
  357.